You can find it on your Updates page. The new builds should be up on Humble soon too (check the version numbers on the files).
This is a quick bug-fixing update. Due to a rogue dev-debug-mode flag being mistakenly switched on in 0.1.2, much of the standard Lua library was accessible. So if you've started using PICO-8 recently, not knowing the library is not supposed to be there and tried to use it, sorry about the confusion!
v0.1.3 Changes:
Added: paste into commandline
Fixed: lua standard libraries accessible
Fixed: command-line loading doesn't work
Fixed: music pattern finished too early when all tracks set to looping
Fixed: peek()ing odd bytes in sfx address space masks bit 7
Fixed: cstore and reload from code space should have no effect
10 comments
Check your updates page!
Note: If you bought PICO-8 (rather than Voxatron), it isn't possible yet to activate your Lexaloffle account from Humble. I've been activating accounts manually, so if you purchased PICO-8 very recently and don't see it show up yet, please check back in a day or so. The Humble Bundle library builds should be live soon too.
New stuff: HTML5 exporter, 8-player joystick support, cartridge save data.
To export your cartridge as a stand-alone html5 version:
EXPORT BLAH.HTML |
Open the folder (FOLDER) and you should be able to see BLAH.HTML and BLAH.JS
Here's a demo of cartridge saving. Note that save data is not persistent yet in the web version:
Changelog:
Z to change colours
X to change shapes
LEFT and RIGHT to select presets slot
note: Saving doesn't work in the web version yet!
old version:
Just a quick note for blog-checkers, Voxatron 0.3.3 and PICO-8 0.1.2 are both arriving this month.
I'll go into detail about new Voxatron developments and plans after the update's out, but here's a quick preview until then.
Also, here's the current changelog for pico-8 0.1.2. There are still known issues that I've rolled over to 0.1.3 but let me know if I missed something small that's easy to fix!
Issue #1 of the community-made PICO-8 zine is out! You can order the 48-page printed version via pico8fanzine.bigcartel.com for a nominal fee, or download the pdf (mirror).
Much respect to @arnaud_debock and contributors for putting this together -- it's humbling to see the world of PICO-8 extended in such a creative and kick-ass way. Issue #1 includes artwork and articles by @dotsukiHARA, @bitmoo, @TheRealMolen, @pizzamakesgames, @PROGRAM_IX, @aliceffekt, @modernmodron and @terrycavanagh. I also took the opportunity to write something on the history of PICO-8 and it's relationship with other Lexaloffle projects.
If you'd like to contribute to future issues, see also this thread, or tweet @arnaud_debock"> @arnaud_debock.
Seeing what kind of heavy splashy snare I can get with multiple sfx channels.
As usual, please use or adapt the music for something if you like.
This cart demonstrates basic wall collisions, animation and actor-based world objects. I hope it's useful either as something to study for ideas, or as a starting template for a platformer or overhead map-based game. I noticed a few carts reusing stuff from Jelpi, which is great -- but Jelpi might be a little complex to get started with.
See move_actor() for the important part:
if not solid_area(a.x + a.dx, a.y, a.w, a.h) then a.x += a.dx else -- otherwise bounce a.dx *= -a.bounce sfx(2) end -- ditto for y if not solid_area(a.x, a.y + a.dy, a.w, a.h) then a.y += a.dy else a.dy *= -a.bounce sfx(2) end |
The collisions work like this:
- wall sprites are tagged with flag 1 (orange) in the sprite editor
- solid_area() checks to see if a given rectangle in the map overlaps with any walls
- each actor has a velocity (a.dx, a.dy)
- in move_actor(): before moving an actor along each axis (x, then y), the new potential collision rectangle of the actor is tested against the map. Note the "+ a.dx" in the call to solid_area() to give the candidate position rather than the current one.
- If the candidate rectangle includes a wall, then the movement along that axis is rejected (and it bounces instead).
This means that as long as actors start outside of walls, they should never end up inside a wall.
There are many minor improvements that could be made -- for example, placing the actor exactly against the wall after it collides. But I've tried to keep it simple to demonstrate only the important concepts.
Note that none of this is the 'right' way to do collisions or anything else in pico-8 -- it's just the way I happen to do it.
If you have any questions about how it works, don't be shy!
EDIT: another example -- this time also with actor collisions.
Exactly the same principle, but instead of looking for solid walls, it searches through all the actors and checks for overlapping actor collision rectangles.
15 
|
A music cart. Feel free to use for anything, especially if you can think of a game that would be called Droid Boots.
There isn't yet a good way to copy music between carts, but if you save as .p8, you can paste the sfx and music data using a text editor.
The last inventories thing I needed for 0.3.3: adaptive formatting (an extreme example). Each inventory item is assigned a group (left, middle, right), and it does its best to figure out how to format everything in a sensible way that doesn't jump around too much and doesn't overlap. I had to be careful not to end up with a 1996 html table renderer!
It's possible with the new inventory system to display the capacity of an item (e.g. empty slots for up to 5 potions), to draw different icons for wielded or carried, and to draw different icons depending on how much ammo each one has.
To handle 1p vs multiplayer inventories, you can tag animations with context information -- how many players should exist for them to be displayed and with which attributes. For example, a single player inventory might show a row of potions, but when playing multiplayer it might be displayed as a single icon with a number to save space.
There's not long to go before 0.3.3 -- just a few microscripting details and converting legacy cartridges over to the new system on load. 0.3.4 will be a smaller follow-up, so let me know if there's something you're hanging out for, and I'll see if I can bump it up, or make sure it will be possible with Lua scripting later on. Things that were recently mentioned and are already confirmed:
- pico-8 music tracker and music triggering (and some new music!)
- custom inventories with selection and/or button bindings
- inventory microscripting (check for number of arrows in a quiver etc.)
- items that share the same ammo (e.g. all spells cost MP)
- id duplication and aliasing bugs after copy/paste
- fixed density allowing actors to sink in liquid
- scroll-wheel zoom, mb3 camera movement , alt-click mb2 emulation
- fixed total playtime bug for speedruns, made restarts faster
There are a few things that are wishlisted, but might be better suited to Lua scripting later on:
- player selection menu
- separate inventory menu
- assigning chase targets to monsters (for waypoints or making snakey monsters)
- arcade style lives
This is a quick demo of cart data compression, in order to fit more gfx / maps / music / whatever on a single cart. It's not set up to be a useful tool yet, but you can adapt it if you're keen!
It comes with two functions: comp and decomp that can be used to compress a section of memory to another location, and then back again. You'd only need to include decomp() in the release version of your cart, which is around 95 tokens.
comp(source_addr, destination_addr, length) decomp(source_addr, destination_addr, length) |
If you'd like to try it on your own data to see what kind of compression ratios you can get, copy and paste the program into your cart and then change this line near the end:
len = comp(0x2000,0x6000,0x1000)
0x2000 is where to compress from (in this case, the map -- see pico8.txt and search for memory layout)
0x6000 where to compress to. In this case, the screen -- as a way to visualize what's going on
0x1000 the length of the data to compress. 0x1000 (4k) is the top half of the map.
So if you want to try compressing the first 16 SFXs (68 bytes each), use:
len = comp(0x3200, 0x6000, 68*16)
The general strategy for developing Voxatron's toolset is to provide specialized features (modifiers, microscripting, physics properties etc) that capture 90% of a typical designer's requirements, and then leave the rest to Lua scripting. Lua will be kind of like a glue that that holds the engine together and fills in the gaps of functionality.
Working on custom player inventories and menus that have a plethora of possible requirements, I feel I've hit that 90% boundary. The engine is now complete enough that it is possible to create a Lua API that is grounded in something stable and maintainable. For this purpose, I've created a text editor that can be used within Designer, and a custom version of Lua designed to work efficiently with Voxatron (both of which you can see in action in PICO-8). It's time to (carefully) plug everything in and see what happens!
It will also be possible to write cartridges from scratch in Lua, of course. This would be handy for making games that need their own style of physics, or things like RTS, sim or puzzle games that deviate a lot from typical Voxatron shooty-runny things. The purest cartridge can contain simply one Lua script, and no rooms or object definitions.
If all goes well, I'll start to roll out a minimal API later next month for anyone to experiment with. It is a typical object-wise callback scheme, where things happening in the world/engine call Lua functions that the cart designer provides.
Here's a simple example:
This is a regular twirly gun using emitters to shoot out the bullets. I've attached a script to each bullet (it's just a SCRIPT item that sits anywhere in the bullet's resource tree) that looks like this:
function this.new() local a = new_bullet() a.col = 12 return a end function this.draw(a) local x,y,z = a:xyz() line3d(x,y,z-30,x,y,z-5,a.col) end |
Every time a bullet is created, the new() function is called (if one exists), and some Lua data (a table, to be precise) is attached to that object. Now, any time something happens to the bullet -- it's moved or drawn or collides -- a corresponding function is called. Here I've only provided a single function that is called by the engine each time the bullet is drawn which grabs the bullet's world position and draws a line straight up.
If you're new to programming and want to get a head-start, I would suggest playing around with PICO-8, which is free for all existing Voxatron alpha users (including the earlier Humble Bundles). Have a look at the Updates Page for download instructions.
Incidentally, I am relatively new to Lua scripting myself! So if you have any feedback or questions about Voxatron scripting, feel free to post here.
PICO-8 0.1.1 is now available! Grab it from the Updates page.
Note that PICO-8 is available to all Voxatron alpha users (including bundle customers). You may need to activate your account, or log in via email if you don't have a username/password already set up.
I'm doing things a little out of order here.. a full introductory post to PICO-8 will follow in a bit for those who haven't been around lately, but for now here's a rundown of new stuff in 0.1.1..
1. Gif saving! Press F9 to save the last 8 seconds (or F8 to set a starting point if you wish)
2. Token counting.
Instead of limiting cartridges to ~15k of ascii text, the primary limit is now 8192 tokens. I say primary limit, because the character count still stands, but is now 32k -- in practice the token limit is almost always reached first. There is actually also a third limit when saving cartridges -- the code must compress to the original 15k allocation. Exceeding this is extremely rare and you can probably ignore it! To get the status of your program, use the new INFO() command.
There aren't currently any cartridges that I know of that go over 8k tokens, and in general this change will give you around 20~30% more space.
3. Freeform sprite and map editing
You can now zoom out with the mousewheel and pan around using space. There is also a more traditional selection tool (you can use cursors to move the selection around). See the manual for more details.
4. New api functions
By popular demand, sqrt(), atan2() and sub() have been added.
atan2() follows the convention set by cos() and sin() of flipping y so that angles increase anti-clockwise in screenspace and reach a full circle at 1.0. So atan2(0,-1) is 0.25
To grab the length of a string, you can use the now-fixed # operator (#s) and grab individual characters with sub(s,pos,pos)
5. More palette control
Palette mapping now applies to all draw operations (note: there is a tiny bit of palette weirdness for existing carts because of this)
Also, you can specify which colours spr(), sspr() and map() should treat as transparent using palt()
palt(1, true) -- don't draw any dark blue pixels
6. Better saving, loading and re-loading
You can now quick-save with CTRL-S. Saving over files, or quitting without saving causes a backup to be saved in [pico-8 home]/backup.
When loading a .png, you can now omit the ".p8.png" and pico-8 will check for it.
Using CTRL-R will automatically reload the cartridge if no changes have been made (making it easier to work with external editors for heretics).
--
Thanks so much to everyone who has given suggestions and shaped the direction of this project. I'm really happy with the way token counting in particular has worked out, but the proof will be in the pudding! Let me know if there are any show-stopping problems that should be nipped in the bud, and I'll include them in a bug-fixing update next week (that will also hopefully include keyboard mapping & broken Yosemite mouse fixes).
Test 0.1.1 cart:
Full changelog:
Birthday cart for my brother John. Please wish him a happy birthday!
Hi All
A quick note on two changes relating to PICO-8 and Voxatron carts:
-
I changed the cart submission system so that's harder to accidentally create version-spam threads. The standard way to update a cartridge is to upload the cartridge and then paste the tag into the existing thread. The new submissions walks new users through this a bit more clearly.
- Cartridge stars (likes?) and thread stars are now exactly the same thing. So if you upload a new version of a cartridge and insert it into the existing thread, any likes or favorites will carry over.
Testing Voxatron cartridge player
|
33
|
PICO-8! This is quick test of the cart format and html5 web player.
Voxatron users: check your account page :) PICO-8 is another fantasy console being co-developed with Voxatron as an included target platform. If you try it out, you might notice that the two already share the same audio tools. I'll be folding the new music editor into Voxatron for 0.3.3 which will be available soon.
Check back to www.pico-8.com tomorrow for more info.
View Older Posts
